package cn.skylark.wcm.controller;

import cn.skylark.wcm.common.redis.RedisUtils;
import cn.skylark.wcm.common.util.PasswordHelper;
import cn.skylark.wcm.common.util.ReturnMap;
import cn.skylark.wcm.entity.Role;
import cn.skylark.wcm.entity.User;
import cn.skylark.wcm.service.RoleService;
import cn.skylark.wcm.service.UserRoleService;
import cn.skylark.wcm.service.UserService;
import com.github.pagehelper.PageInfo;
import io.swagger.annotations.Api;
import net.sf.json.JSONArray;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 用户控制器类
 *
 * @author 武文旭
 * @Date 20180109
 * @since
 */
@Api(value = "用户相关的接口")
@RestController
@RequestMapping("/users")
public class UserController {
    /**
     * logger
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(UserController.class);
    @Autowired
    UserService userService;

    @Autowired
    RedisUtils redisutil;
    @Autowired
    UserRoleService userRoleService;
    @Autowired
    RoleService roleService;

    /**
     * 获取租户下所有用户
     * 1、业务要求根据组户id获取所有用户
     * 通过租户id返回当前租户下的所有用户
     *
     * @param user   User 用户对象
     * @param start  int
     * @param length int
     * @return Map<String,Object>
     */
    @RequestMapping("/getAllUserByTenanid")
    public Map<String, Object> getAllUserByTenanid(User user,HttpServletRequest request,
                                                   @RequestParam(required = false, defaultValue = "1") int start,
                                                   @RequestParam(required = false, defaultValue = "10") int length) {

        LOGGER.info("获取所有用户开始 user+" + user + "start=" + start + "length=" + length);
        Map<String, Object> map = new HashMap<>();
        try {
            String searchValue = request.getParameter("search[value]");
            String flag = request.getParameter("flag");
            LOGGER.info("search:" + searchValue);
            PageInfo<User> pageInfo = userService.selectByPage(user, flag, searchValue, start, length);
            map.put("code", 0);
            map.put("message", "用户对象获取成功");
            map.put("recordsTotal", pageInfo.getTotal());
            map.put("recordsFiltered", pageInfo.getTotal());
            map.put("data", pageInfo.getList());
            LOGGER.info("获取所有用户结束");
            return map;
        } catch (Exception e) {
            e.printStackTrace();
            map.put("code", 2);
            map.put("message", "用户对象获取失败");
            return map;
        }
    }

    /**
     * 通过id查询所拥有的角色
     * 1、当是新建用户的时候查的是返回的是租户下的所有角色
     * 2、当是通过userid查询是返回用户所拥有的角色
     *
     * @param tenanid Integer
     * @param userid  Integer
     * @return List<Role>
     * @Exception e 数据库错误异常
     */
    @RequestMapping("/getRoleById")
    public String getRoleByTenanId(Integer tenanid, Integer userid) {
        LOGGER.info("通过id查询所拥有的角色开始 租户id:" + tenanid + "用户id:" + userid);
        ReturnMap ret = new ReturnMap();
        try {
            if (userid == null) {
                List<Role> roleList = roleService.queryRoleListWithTennerId(tenanid);
                ret.setFlg(0);
                ret.setMessage("成功！");
                ret.setData(net.sf.json.JSONArray.fromObject(roleList).toString());
            } else {
                List<Role> useridList = roleService.queryRoleListWithSelected(userid);
                ret.setFlg(0);
                ret.setMessage("成功！");
                ret.setData(net.sf.json.JSONArray.fromObject(useridList).toString());
            }
            LOGGER.info("通过id查询所拥有的角色开始结束");
            return ret.ReturnMap();
        } catch (Exception e) {
            LOGGER.info("异常信息为=" + e);
            e.printStackTrace();
            ret.setFlg(2);
            ret.setMessage("失败！");
            return ret.ReturnMap();
        }
    }

    /**
     * 添加用户
     * 1、首先通过用户名判断用户是否存在，存在提示
     * 2、不存在新增
     *
     * @param user User
     * @return String
     * @Exception e 数据库异常信息
     */
    @RequestMapping(value = "/add")
    public String add(User user) {
        LOGGER.info("添加用户开始 user=" + user);
        ReturnMap ret = new ReturnMap();
        try {
            User userName = new User();
            userName.setTenanid(user.getTenanid());
            userName.setUsername(user.getUsername());
            Integer u = userService.selectByUsername(userName);
            if (u > 0) {
                LOGGER.info("用户已存在");
                ret.setFlg(1);
                ret.setMessage("用户已存在！");
                return ret.ReturnMap();
            }
            user.setEnable(1);
            PasswordHelper passwordHelper = new PasswordHelper();
            String pwd = passwordHelper.encrypt(user.getPassword());
            user.setPassword(pwd);
            user.setDelflg(0);
            userService.addUser(user);
            LOGGER.info("添加用户结束");
            ret.setFlg(0);
            ret.setMessage("添加成功！");
            return ret.ReturnMap();
        } catch (Exception e) {
            LOGGER.info("异常信息为=" + e);
            e.printStackTrace();
            ret.setFlg(2);
            ret.setMessage("添加失败！");
            return ret.ReturnMap();
        }
    }

    /**
     * 删除用户
     * <p>
     * 业务:user表中将delflg状态改为1，进行逻辑删除
     *
     * @param id Integer
     * @return String
     * @Exception e 数据库异常信息
     */
    @RequestMapping(value = "/delete")
    public String delete(Integer id) {
        LOGGER.info("删除用户开始 id=" + id);
        ReturnMap ret = new ReturnMap();
        try {
            userService.delUser(id);
            LOGGER.info("删除用户结束！");
            ret.setFlg(0);
            ret.setMessage("删除成功！");
            return ret.ReturnMap();
        } catch (Exception e) {
            LOGGER.info("异常信息为=" + e);
            e.printStackTrace();
            ret.setFlg(2);
            ret.setMessage("删除失败！");
            return ret.ReturnMap();
        }
    }

    /**
     * 更改用户状态
     * 将enable状态改为0或1
     * 是用户状态由恢复和冻结切换
     *
     * @param user
     * @return
     * @Exception e 数据库异常信息
     */
    @RequestMapping(value = "/updatestate")
    public String updatestate(User user) {
        LOGGER.info("变更用户开始 id=" + user.getId());
        ReturnMap ret = new ReturnMap();
        try {
            User userId = userService.selectUserById(user);
            if (userId.getEnable() == 0) {
                userService.updateStateFrozen(userId.getId());
            } else {
                userService.updateStateRecovery(userId.getId());
            }
            LOGGER.info("变更用户结束");
            ret.setFlg(0);
            ret.setMessage("更改成功！");
            return ret.ReturnMap();
        } catch (Exception e) {
            LOGGER.info("异常信息为=" + e);
            e.printStackTrace();
            ret.setFlg(2);
            ret.setMessage("更改失败！");
            return ret.ReturnMap();
        }
    }

    /**
     * 通过用户的id获取用户的个人资料数据
     * 1、通过用户的id为条件，查询用户的个人资料
     *
     * @param user 用户的id
     * @return user
     * @Exception e 为数据库连接异常
     */
    @RequestMapping("/getUserData")
    public String getUserData(User user) {
        LOGGER.info("通过用户的id获取用户的个人资料数据开始 id=" + user.getId());
        ReturnMap ret = new ReturnMap();
        try {
            User userdata = userService.getUserDataById(user);
            LOGGER.info("通过用户的id获取用户的个人资料数据结束");
            ret.setFlg(0);
            ret.setMessage("查询成功！");
            ret.setData(JSONArray.fromObject(userdata).toString());
            return ret.ReturnMap();
        } catch (Exception e) {
            LOGGER.info("异常信息为=" + e);
            e.printStackTrace();
            ret.setFlg(2);
            ret.setMessage("查询失败！");
            return ret.ReturnMap();
        }
    }

    /**
     * 通过上传的用户信息，对用户信息进行新增
     * 1、因为租户信息不能删除，所有租户的字段在uodate不做更改
     * 2、能更改的字段，使用if判断，是否传的值为空，空不做更改
     *
     * @param user 用户的id
     * @return user用户个人资料对象
     * @Exception e 为数据库连接异常
     */
    @RequestMapping("/saveUserData")
    public String saveUserData(User user) {
        LOGGER.info("通过上传的用户信息，对用户信息进行新增 user=" + user.getUsername());
        ReturnMap ret = new ReturnMap();
        try {
            userService.saveUserDataById(user);
            LOGGER.info("通过上传的用户信息，对用户信息进行新增结束");
            ret.setFlg(0);
            ret.setMessage("保存成功！");
            return ret.ReturnMap();
        } catch (Exception e) {
            LOGGER.info("异常信息为=" + e);
            e.printStackTrace();
            ret.setFlg(2);
            ret.setMessage("保存失败！");
            return ret.ReturnMap();
        }
    }

    /**
     * 通过用户id修改密码
     * 1、首先通过id查看用户的信息，将返回的用户信息中的密码和之前的密码比对
     * 2、相同更改密码,不同做出提示
     *
     * @param id
     * @param opwd
     * @param npwd
     * @return 提示信息
     * @Exception e 数据库连接异常
     */
    @RequestMapping("/updatePassword")
    public String updatePassword(Integer id, String opwd, String npwd) {
        LOGGER.info("通过用户id修改密码开始 Integer=" + id + "oidPassword" + opwd + "newPassword" + npwd);
        ReturnMap ret = new ReturnMap();
        try {
            //获取现有用户信息
            User user = new User();
            user.setId(id);
            User userdata = userService.getUserDataById(user);
            //对数据库密码进行解密
            PasswordHelper passwordHelper = new PasswordHelper();
            if (passwordHelper.decrypt(userdata.getPassword()).equals(opwd)) {
                userdata.setPassword(passwordHelper.encrypt(npwd));
                //新密码加密并更新密码
                userService.updatePassword(userdata);
                LOGGER.info("通过用户id修改密码结束");
                ret.setFlg(0);
                ret.setMessage("修改密码成功！");
                return ret.ReturnMap();
            } else {
                ret.setFlg(1);
                ret.setMessage("密码有误！");
                return ret.ReturnMap();
            }
        } catch (Exception e) {
            LOGGER.info("异常信息为=" + e);
            e.printStackTrace();
            ret.setFlg(2);
            ret.setMessage("修改密码失败！");
            return ret.ReturnMap();
        }
    }

}
